/**
 * 数据验证工具类
 * 用于验证图表数据格式的正确性
 */

class DataValidator {
  /**
   * 验证图表数据格式
   */
  validateChartData(data, chartType) {
    const result = {
      isValid: false,
      error: '',
      warnings: []
    };

    try {
      // 基础验证
      if (!data || !Array.isArray(data)) {
        result.error = '数据必须是数组格式';
        return result;
      }

      if (data.length === 0) {
        result.error = '数据不能为空';
        return result;
      }

      // 根据图表类型进行特定验证
      switch (chartType) {
        case 'line':
        case 'bar':
          return this.validateLineBarData(data);
        case 'pie':
          return this.validatePieData(data);
        case 'scatter':
          return this.validateScatterData(data);
        case 'area':
          return this.validateAreaData(data);
        default:
          return this.validateGenericData(data);
      }
    } catch (error) {
      result.error = `数据验证失败: ${error.message}`;
      return result;
    }
  }

  /**
   * 验证折线图/柱状图数据
   */
  validateLineBarData(data) {
    const result = { isValid: false, error: '', warnings: [] };

    // 检查数据结构
    for (let i = 0; i < data.length; i++) {
      const item = data[i];
      if (typeof item !== 'object' || item === null) {
        result.error = `第${i + 1}行数据格式错误，应为对象格式`;
        return result;
      }

      const keys = Object.keys(item);
      if (keys.length < 2) {
        result.error = `第${i + 1}行数据至少需要2个字段（X轴和Y轴）`;
        return result;
      }

      // 检查是否有数值字段
      const hasNumericValue = keys.some(key => {
        const value = item[key];
        return !isNaN(parseFloat(value)) && isFinite(value);
      });

      if (!hasNumericValue) {
        result.warnings.push(`第${i + 1}行数据缺少数值字段`);
      }
    }

    result.isValid = true;
    return result;
  }

  /**
   * 验证饼图数据
   */
  validatePieData(data) {
    const result = { isValid: false, error: '', warnings: [] };

    for (let i = 0; i < data.length; i++) {
      const item = data[i];
      if (typeof item !== 'object' || item === null) {
        result.error = `第${i + 1}行数据格式错误，应为对象格式`;
        return result;
      }

      const keys = Object.keys(item);
      if (keys.length < 2) {
        result.error = `第${i + 1}行数据至少需要2个字段（名称和数值）`;
        return result;
      }

      // 饼图必须有数值字段
      const hasNumericValue = keys.some(key => {
        const value = item[key];
        return !isNaN(parseFloat(value)) && isFinite(value) && parseFloat(value) >= 0;
      });

      if (!hasNumericValue) {
        result.error = `第${i + 1}行数据缺少有效的数值字段（必须为非负数）`;
        return result;
      }
    }

    result.isValid = true;
    return result;
  }

  /**
   * 验证散点图数据
   */
  validateScatterData(data) {
    const result = { isValid: false, error: '', warnings: [] };

    for (let i = 0; i < data.length; i++) {
      const item = data[i];
      if (typeof item !== 'object' || item === null) {
        result.error = `第${i + 1}行数据格式错误，应为对象格式`;
        return result;
      }

      const keys = Object.keys(item);
      if (keys.length < 2) {
        result.error = `第${i + 1}行数据至少需要2个字段（X轴和Y轴）`;
        return result;
      }

      // 散点图需要至少两个数值字段
      const numericFields = keys.filter(key => {
        const value = item[key];
        return !isNaN(parseFloat(value)) && isFinite(value);
      });

      if (numericFields.length < 2) {
        result.error = `第${i + 1}行数据至少需要2个数值字段作为X轴和Y轴坐标`;
        return result;
      }
    }

    result.isValid = true;
    return result;
  }

  /**
   * 验证面积图数据
   */
  validateAreaData(data) {
    // 面积图验证规则与折线图相同
    return this.validateLineBarData(data);
  }

  /**
   * 通用数据验证
   */
  validateGenericData(data) {
    const result = { isValid: false, error: '', warnings: [] };

    for (let i = 0; i < data.length; i++) {
      const item = data[i];
      if (typeof item !== 'object' || item === null) {
        result.error = `第${i + 1}行数据格式错误，应为对象格式`;
        return result;
      }

      const keys = Object.keys(item);
      if (keys.length === 0) {
        result.error = `第${i + 1}行数据不能为空对象`;
        return result;
      }
    }

    result.isValid = true;
    return result;
  }

  /**
   * 转换表格数据为图表数据格式
   */
  convertTableToChartData(headers, tableData, chartType) {
    if (!headers || !tableData || headers.length === 0 || tableData.length === 0) {
      return [];
    }

    try {
      // 根据图表类型进行不同的转换
      switch (chartType) {
        case 'line':
        case 'bar':
        case 'area':
          return this.convertToXYData(headers, tableData);
        case 'pie':
          return this.convertToPieData(headers, tableData);
        case 'scatter':
          return this.convertToScatterData(headers, tableData);
        default:
          return this.convertToGenericData(headers, tableData);
      }
    } catch (error) {
      console.error('数据转换失败:', error);
      return [];
    }
  }

  /**
   * 转换为X-Y轴数据格式
   */
  convertToXYData(headers, tableData) {
    return tableData.map(row => {
      const obj = {};
      headers.forEach((header, index) => {
        const value = row[index] || '';
        // 尝试转换为数字，如果失败则保持原值
        if (index > 0 && !isNaN(parseFloat(value)) && isFinite(value)) {
          obj[header] = parseFloat(value);
        } else {
          obj[header] = value;
        }
      });
      return obj;
    });
  }

  /**
   * 转换为饼图数据格式
   */
  convertToPieData(headers, tableData) {
    return tableData.map(row => {
      const obj = {};
      headers.forEach((header, index) => {
        const value = row[index] || '';
        // 第二列及以后尝试转换为数字
        if (index > 0 && !isNaN(parseFloat(value)) && isFinite(value)) {
          obj[header] = parseFloat(value);
        } else {
          obj[header] = value;
        }
      });
      return obj;
    });
  }

  /**
   * 转换为散点图数据格式
   */
  convertToScatterData(headers, tableData) {
    return tableData.map(row => {
      const obj = {};
      headers.forEach((header, index) => {
        const value = row[index] || '';
        // 前两列尝试转换为数字（X轴和Y轴）
        if (index < 2 && !isNaN(parseFloat(value)) && isFinite(value)) {
          obj[header] = parseFloat(value);
        } else {
          obj[header] = value;
        }
      });
      return obj;
    });
  }

  /**
   * 转换为通用数据格式
   */
  convertToGenericData(headers, tableData) {
    return tableData.map(row => {
      const obj = {};
      headers.forEach((header, index) => {
        obj[header] = row[index] || '';
      });
      return obj;
    });
  }

  /**
   * 验证JSON字符串
   */
  validateJsonString(jsonString) {
    const result = {
      isValid: false,
      error: '',
      data: null
    };

    try {
      if (!jsonString || jsonString.trim() === '') {
        result.error = 'JSON数据不能为空';
        return result;
      }

      const data = JSON.parse(jsonString);
      result.data = data;
      result.isValid = true;
      return result;
    } catch (error) {
      result.error = `JSON格式错误: ${error.message}`;
      return result;
    }
  }
}

// 创建全局实例
const dataValidator = new DataValidator();

module.exports = dataValidator;